﻿#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <algorithm>
#include <string>
#include <list>
#include <stack>
#include <vector>
#include <assert.h>
using namespace std;


//class Date
//{
//public:
//	Date(int year = 2024, int month = 1, int day = 11)
//	{
//
//		_year = year;
//		_month = month;
//		_day = day;
//
//		if (_year < 1 ||
//			_month < 1 || _month > 12 ||
//			_day < 1 || _day > GetMonthDay(_year, _month))
//		{
//			//assert(false);
//			cout << *this;
//			cout << "日期非法" << endl;
//		}
//
//		
//	}
//	Date(const Date& d)
//		:_year(d._year), _month(d._month), _day(d._day)
//	{}
//	// 析构函数
//
//	~Date()
//	{
//		//cout << "~Date()" << endl;
//	}
//	// 重载 <<、>>
//	friend ostream& operator<< (ostream& out, const Date& d);
//	friend istream& operator>> (istream& in, Date& d);
//
//	// 获取某年某月的天数
//	int GetMonthDay(int year, int month)
//	{
//		// 检查数据是否合法
//		assert(year >= 1 && month >= 1 && month <= 12);
//
//		int Month_day[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
//		if (month != 2)
//			return Month_day[month];
//		else
//		{
//			// 判断该年是不是闰年
//			if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0))
//				return Month_day[month] + 1;
//			return Month_day[month];
//		}
//	}
//
//
//	// 赋值运算符重载
//
//	// d2 = d3 -> d2.operator=(&d2, d3)
//
//	Date& operator=(const Date& d)
//	{
//		_year = d._month;
//		_month = d._month;
//		_day = d._day;
//		return *this;
//	}
//
//	// 日期+=天数
//	Date& operator+=(int day)
//	{
//		_day += day;
//		while (_day > GetMonthDay(_year, _month))
//		{
//			_day -= GetMonthDay(_year, _month);
//			_month++;
//			if (_month > 12)
//			{
//				_year++;
//				_month -= 12;
//			}
//		}
//		return *this;
//	}
//
//	// 日期+天数
//
//	Date operator+(int day)
//	{
//		Date temp = *this;
//		temp += day;
//		return temp;
//	}
//
//
//	// 日期-=天数
//
//	Date& operator-=(int day)
//	{
//		if (day < 0)
//		{
//			return *this += (-day);
//		}
//
//		_day -= day;
//		while (_day <= 0)
//		{
//			--_month;
//			if (_month == 0)
//			{
//				--_year;
//				_month = 12;
//			}
//
//			_day += GetMonthDay(_year, _month);
//		}
//
//		return *this;
//	}
//
//	// 日期-天数
//
//	Date operator-(int day)
//	{
//		Date temp = *this;
//		temp -= day;
//		return temp;
//	}
//
//	// 前置++
//
//	Date& operator++()
//	{
//		(*this) += 1;
//		return *this;
//	}
//	// 后置++
//
//	Date operator++(int)
//	{
//		Date temp = *this;
//		++(*this);
//		return temp;
//	}
//
//	// 后置--
//
//	Date operator--(int)
//	{
//		Date temp = *this;
//		--(*this);
//		return temp;
//	}
//
//
//
//	// 前置--
//
//	Date& operator--()
//	{
//		(*this) -= 1;
//		return *this;
//	}
//
//
//	// >运算符重载
//
//	bool operator>(const Date& d)
//	{
//		if (_year > d._year)
//			return true;
//		else if (_year == d._year && _month > d._month)
//			return true;
//		else if (_year == d._year && _month == d._month && _day > d._day)
//			return true;
//		
//		return false;
//	}
//
//	// ==运算符重载
//
//	bool operator==(const Date& d)
//	{
//		return _year == d._year && _month == d._month && _day == d._day;
//	}
//
//	// >=运算符重载
//
//	bool operator >= (const Date& d)
//	{
//		return (*this) > d || (*this) == d;
//	}
//
//	// <运算符重载
//
//	bool operator < (const Date& d)
//	{
//		return !(*this >= d);
//	}
//
//	// <=运算符重载
//
//	bool operator <= (const Date& d)
//	{
//		return *this < d || *this == d;
//	}
//
//	// !=运算符重载
//
//	bool operator != (const Date& d)
//	{
//		return !(*this == d);
//	}
//
//	// 日期-日期 返回天数
//
//	int operator-(const Date& d)
//	{
//		int flag = 1; // 左大右小
//		Date max = *this;
//		Date min = d;
//		
//		// 假设错误
//		if (*this < d)
//		{
//			max = d;
//			min = *this;
//			flag = -1;
//		}
//		int count = 0;
//		while (min != max)
//		{
//			++min;
//			++count;
//		}
//		return count * flag;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//ostream& operator<< (ostream& out, const Date& d)
//{
//	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
//	return out;
//}
//istream& operator>> (istream& in, Date& d)
//{
//	cout << "请输入年份：" << endl;
//	in >> d._year;
//	cout << "请输入月份：" << endl;
//	in >> d._month;
//	cout << "请输入天数：" << endl;
//	in >> d._day;
//}
//
//int main()
//{
//	Date d;
//	d += 1000;
//	cout << d;
//	++d;
//	cout << d;
//	return 0;
//}


//// 前置++
//Vector& operator++()
//{
//    ++_x1;
//    ++_x2;
//    ++_x3;
//    return *this;
//}
//
//// 后置++
//Vector operator++(int)
//{
//    Vector temp(*this);
//    ++_x1;
//    ++_x2;
//    ++_x3;
//    return temp;
//}
//
//// 前置--
//Vector& operator--()
//{
//    --_x1;
//    --_x2;
//    --_x3;
//    return *this;
//}
//
//// 后置--
//Vector operator--(int)
//{
//    Vector temp(*this);
//    --_x1;
//    --_x2;
//    --_x3;
//    return temp;
//}

//bool isExist(const string& s, const char c)
//{
//    for (auto e : s)
//    {
//        if (e == c)
//            return true;
//    }
//    return false;
//}
//class Solution
//{
//public:
//    int lengthOfLongestSubstring(const string& s)
//    {
//        string temp;
//        int left = 0, right = 0, len = INT_MIN;
//        int n = s.size();
//        while(right < n)
//        {
//            // 进窗口
//            if (!isExist(temp, s[right]))
//                temp += s[right++];
//
//            // 判断
//            while (isExist(temp, s[right]))
//            {
//                // 更新结果
//                len = max(len, right - left);
//                temp.erase(0, 1);
//                left++;
//            }
//        }
//        return len == INT_MIN ? temp.size() : len;
//    }
//};
//
//int main()
//{
//    string s = " ";
//    Solution ret;
//    cout << ret.lengthOfLongestSubstring(s) << endl;
//    return 0;
//}
//int main()
//{
//	char a = -128;
//	int count = 257;
//	while (count--)
//	{
//		printf("%d ", a);
//		a++;
//		
//	}
//	
//	
//	return 0;
//}

//#include <stdio.h>
//int main()
//{
//	int a = 0x00000001;
//	int b = (char)a;
//	if (b == 1)
//		printf("小端\n");
//	else if (b == 0)
//		printf("大端\n");
//	return 0;
//}





//int main()
//{
//	int a = 1;
//	char* pa = (char*) & a;
//	if (*pa == 1)
//		printf("小端\n");
//	else
//		printf("大端\n");
//	return 0;
//}



//输出什么？
//#include <stdio.h> 
//int main()
//{
//	char a = -1;
//	signed char b = -1; 
//	unsigned char c = -1;  
//	printf("a=%d,b=%d,c=%d", a, b, c); 
//	return 0;
//}

//#include <stdio.h>
//int main()
//{
//	char a = -128;
//	printf("%u\n", a);
//	return 0;
//}

//#include <stdio.h>
//int main()
//{
//	char a = 128;
//	printf("%u\n", a);
//	return 0;
//}
//#include <stdio.h>
//int main()
//{
//	int i = -20;
//	unsigned int j = 10;
//	printf("%d\n", i + j);
//	return 0;
//}

//int main() 
//{
//	char a[1000];
//	int i;
//	for (i = 0; i < 1000; i++)
//	{
//		a[i] = -1 - i;
//	}
//	printf("%d", strlen(a));
//	return 0;
//}

//#include <stdio.h>
//int main()
//{
//	char a = 101; 
//	int sum = 200;
//	a += 27; 
//	sum += a; 
//	printf("%d\n", sum);
//	return 0;
//}


//int main()
//{
//	int value = 1024;
//	char condition = *((char*)(&value));
//	if (condition)
//		value += 1; 
//	condition = *((char*)&value);
//	if (condition)
//		value += 1; 
//	condition = *((char*)(&value));
//	printf("%d %d", value, condition);
//	return 0;
//}

// 32位机器下
//void func(char para[100])
//{
//	void* p = malloc(100);
//	printf("%d, %d\n", sizeof(para), sizeof(p));
//}
//
//int main()
//{
//	char para[100] = { 0 };
//	func(para);
//	return 0;
//}

//void func(char* p)
//{
//	p = p + 1;
//}
//int main()
//{
//	char s[] = { '1', '2', '3', '4' };
//	func(s);
//	printf("%c", *s);
//	return 0;
//}


//#include <iostream>
//#include <type_traits>
//using namespace std;
//bool IsLeapYear(int year)
//{
//    if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
//        return true;
//    else
//        return false;
//}
//int main()
//{
//    int m = 0, n = 0;
//    while (cin >> m >> n)
//    {
//        int year = m, month = 0, day = 0;
//        int month_day[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
//
//        while (n)
//        {
//            n--;
//            day++;
//            if (IsLeapYear(m) && month == 2)
//            {
//                if (day > 29)
//                {
//                    day -= 29;
//                    month++;
//                }
//                
//            }
//            else 
//            {
//                if (day > month_day[month])
//                {
//                    day -= month_day[month];
//                    month++;
//                }
//            }
//            if (month > 12)
//            {
//                year++;
//                month -= 12;
//            }
//        }
//       
//        printf("%4d-%02d-%02d\n", year, month, day);
//    }
//}


//class A
//{
//public:
//    A(int a)
//        :_a1(a)
//        , _a2(_a1)
//    {}
//    void Print()
//    {
//        cout << _a1 << " " << _a2 << endl;
//    }
//
//private:
//
//    int _a2;
//    int _a1;
//};
//
//int main()
//{
//    A aa(1);
//    aa.Print();
//    return 0;
//}


//class A
//{
//public:
//	int _a;
//	int _b;
//};
//class B
//{
//	// 空类
//};
//class C
//{
//public:
//	void func()
//	{
//		cout << "func()" << endl;
//	}
//};
//int main()
//{
//	cout << "A的大小：" << sizeof(A) << endl;
//	cout << "B的大小：" << sizeof(B) << endl;
//	cout << "C的大小：" << sizeof(C) << endl;
//	return 0;
//}

//#include <stdio.h>
//
//int maxProduct(int* nums, int numsSize) {
//    if (numsSize == 0) {
//        return 0; // 处理数组为空的情况
//    }
//
//    int count1 = 0;
//    int count2 = 0;
//    int mul1 = 1;
//    int mul2 = 1;
//    int mul3 = 1;
//    int j = 0;
//    // 负数个数
//    for (int i = 0; i < numsSize; i++) {
//        if (nums[i] < 0) {
//            count1++;
//        }
//    }
//    //假如总元素的负数个数为偶数个，直接返回整个数组的乘积 
//    if (count1 % 2 == 0) {
//        for (int i = 0; i < numsSize; i++) {
//            mul1 = mul1 * nums[i];
//        }
//        return mul1;
//    }
//    //假如是奇数个，用j来记录最后一份负数元素出现的下标，比较最后一下负数元素左右两端的连续序列，返回这两端序列的最大值 
//    else {
//        for (int i = 0; i < numsSize; i++) {
//            if (nums[i] < 0) {
//                count2++;
//            }
//            if (count1 == count2) {
//                j = i;
//                //break;
//            }
//        }
//        for (int i = 0; i < j; i++) {
//            mul2 = mul2 * nums[i];
//        }
//        for (int i = j + 1; i < numsSize; i++) {
//            mul3 = mul3 * nums[i];
//        }
//        int max = (mul2 > mul3) ? mul2 : mul3;
//        return max;
//    }
//}
//
//int main() {
//    int nums[] = { -1, -1, 8, -9,-8,-6,5 };
//    int numsSize = sizeof(nums) / sizeof(nums[0]);
//
//    int result = maxProduct(nums, numsSize);
//
//    printf("The maximum product of a non-empty subarray is: %d\n", result);
//
//    return 0;
//}


//class Date
//{
//private:
//	int _year;
//	int _month;
//	int _day;
//public:
//	Date(int year = 2024, int month = 1, int day = 14)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//	void Print(Date* this)
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//};
//
//int main()
//{
//	Date d1(2023, 12, 12);
//	Date d2;
//	d1.Print();
//	d2.Print();
//	d1.Print(&d1);
//	d2.Print(&d2);
//	return 0;
//}

//#include <stdio.h>
//void fun(const char** p)
//{
//	int i;
//	for (i = 0; i < 4; i++)
//		printf("%s", p[i]);
//}
//int main()
//{
//	const char* s[6] = { "ABCD", "EFGH", "IJKL", "MNOP", "QRST", "UVWX" };
//	fun(s);
//	printf("\n");
//	return 0;
//}


//class Solution
//{
//public:
//    /**
//     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
//     *
//     *
//     * @param str string字符串
//     * @return int整型
//     */
//    int FirstNotRepeatingChar(string str)
//    {
//        // write code here
//        // 利用一个数组哈希表
//        int hash['z' + 1] = { 0 };
//        for (auto e : str)
//        {
//            hash[e]++;
//        }
//        int i = 0;
//        for (auto e : str)
//        {
//            if (hash[e] == 1)
//                return i;
//            i++;
//        }
//        return -1;
//    }
//};
//#include <string>
//
//int main()
//{
//    string str = "google";
//    Solution s;
//    int ret = s.FirstNotRepeatingChar(str);
//    cout << ret << endl;
//    return 0;
//}


//int main()
//{
//	int* k[10][30];
//	printf("%d", sizeof(k));
//	return 0;
//}

//int main()
//{
//	int a[6];
//	printf("%d", sizeof(a));
//	return 0;
//}


//class A
//{
//public:
//	void Print()
//	{
//		cout << "Print()" << endl;
//	}
//private: 
//	int _a;
//};
//int main()
//{
//	A* p = nullptr;
//	p->Print();
//	return 0;
//}

//class A
//{
//public:
//	void PrintA()
//	{
//		cout << _a << endl;
//	}
//private:
//	int _a;
//};
//int main()
//{
//	A* p = nullptr;
//	p->PrintA(); 
//	return 0;
//}



//// 1、
//Date(const Date& d)
//{
//	cout << "Date(Date&d)" << endl;
//	_year = d._year;
//	month = d.month;
//	_day = d._day;
//}
//// 2、
//Date(const Date* d)
//{
//	_year = d->_year;
//	month d->month;
//	_day d->_day;
//}

//stack(const stack& st)
//{
//	_arr = (int*)malloc(sizeof(int) * st._capacity);
//	if (_arr == nullptr)
//	{
//		perror("malloc failed！");
//		exit(-1);
//	}
//	memcpy(_a, st._a, sizeof(int) * st._top);
//	_capacity = st._capacity;
//	_top = st.top;
//}

//Date& operator=(const Date& d)
//{
//	if (this != &d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//	return *this;
//}


//bool operator<(const Date& y);
//
//const Date d1(2023, 10, 31);
//Date d2(2023, 1, 1);
//
//d2 < d1; // right
//d1 < d2; // error


//class Date
//{
//public:
//	Date* operator&()
//	{
//		return this;
//	}
//	const Date* operator&()const
//	{
//		return this;
//	}
//private:
//	int _year; // 年
//	int _month; // 月
//	int _day; // 日
//};
// 
//// 函数体内部进行赋值初始化
//Date(int year, int month, int day)
//{
//	_year = year;
//	_month = month;
//	_day = day;
//}
//
//// 使用初始化列表进行初始化
//Date(int year, int month, int day)
//	:_year(year), _month(month), _day(day)
//{}

//class Date
//{
//public:
//	// ……
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//int main()
//{
//	Date d(2024, 1, 15);
//	return 0;
//}

//class Stack
//{
//public:
//	Stack(int n = 0)
//	{
//		// ……
//	}
//};
//
//class Stack
//{
//public:
//	Stack(int n = 2)
//		:_a((int*)malloc(sizeof(int)* n))
//		, _top(0)
//		, _capacity(n)
//	{
//		// 检查工作，初始化列表是做不了的
//		if (_a = nullptr)
//		{
//			perror("malloc fial");
//			exit(-1);
//		}
//		// 其他工作
//		memset(_a, 0, sizeof(int) * n);
//	}
//};
//class MyQueue
//{
//public:
//	// ……
//private:
//	Stack s1;
//	Stack s2;
//};

//class A
//{
//public:
//	A(int a) // 不是默认构造函数
//		:_a(a)
//	{}
//private:
//	int _a;
//};
//
//class B 
//{
//public: 
//	B(int a, int ref) 
//		:_aobj(a), _ref(ref), _n(10) 
//	{} 
//private:
//	A _aobj;      // 没有默认构造函数
//	int& _ref;    // 引用
//	const int _n; // const 
//};

//class A
//{
//public:
//	A()
//	{
//		++_scount;
//	}
//	A(const A& t)
//	{
//		++_scount;
//	}
//	~A() 
//	{
//		--_scount;
//	}
//	static int GetACount() // 静态成员函数，属于整个类，没有this指针
//	{
//		return _scount;
//	}
//private:
//	static int _scount; // 静态成员变量的声明
//};
//int A::_scount = 0; // 静态成员变量需要在类外进行定义并初始化
//void TestA() 
//{
//	cout << A::GetACount() << endl; 
//	A a1, a2;
//	A a3(a1); 
//	cout << A::GetACount() << endl;
//}


//class A
//{
//public:
//	A(int a)
//		:_a(a)
//	{}
//private:
//	int _a; 
//};
//
//class Date
//{
//public:
//	Date(int year = 2024, int month = 1, int day = 16)
//		:_year(year), _month(month), _day(day)
//	{}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//int main()
//{
//	// 单参数类型转化
//	list<A>lt;
//	A aa1(1);
//	lt.push_back(aa1); // 第一种
//
//	lt.push_back(A(2)); // 第二种
//
//	lt.push_back(3); // 第三种
//
//	// 多参数类型转化
//	list<Date>lt1;
//	Date d6(2023, 11, 2);
//	lt1.push_back(d6); // 第一种
//
//	lt1.push_back(Date(2023, 11, 2)); // 第二种
//
//	lt1.push_back({ 2023,11,2 }); // 第三种
//	return 0;
//}


//int main()
//{
//	char* p;
//	p = getchar(); // getchar是得到一个字符
//	/*char s[] = "China";
//	p = s;*/
//	// *p = "China"; // 无法从 const char[6]转化为char
//
//	return 0;
//}

//#include <iostream>
//#include <string>
//#include <vector>
//using namespace std;
//
//
//string IsLongWorld(string& str)
//{
//    int n = str.size();
//    if (n <= 10)
//        return str;
//    else
//    {
//        string temp;
//        temp.push_back(str[0]);
//        temp += to_string(n - 2);
//        temp.push_back(str.back());
//        return temp;
//    }
//}
//
//int main()
//{
//    int n = 0;
//    cin >> n;
//    vector<string> v;
//    for (int i = 0; i < n; i++)
//    {
//        string str;
//        cin >> str;
//        v.push_back(str);
//    }
//    for (int i = 0; i < n; i++)
//    {
//        cout << IsLongWorld(v[i]) << endl;
//    }
//}


//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//	A(const A& c)
//		:_a(c._a)
//	{
//		cout << "A(A&)" << endl;
//	}
//
//private:
//	int _a; 
//};
//
////int main()
////{
////	//A aa1 = 1;
////	//const A& aa2 = 1;
////	return 0;
////}
//
//A func()
//{
//	A aa; // 构造函数
//	return aa; // 拷贝构造
//}
//
//int main()
//{
//	A ret; // 构造构造
//	ret = func(); // 赋值重载
//	return 0;
//}


//enum weekday
//{
//	sun,
//	mon = 3,
//	tur,
//	wed
//};
//
//int main()
//{
//	enum weekday workday;
//	workday = wed;
//	printf("%d\n", workday);
//	return 0;
//}

//union Un
//{
//	int i;
//	char c;
//};



//union D
//{
//	int d1;
//	float d2;
//};
//
//int main()
//{
//	union D d;
//	d.d1 = 10;
//	printf("%f\n", d.d1);
//	/*d.d1 = 10;
//	printf("%f\n", d.d2);*/
//	return 0;
//}

//union Un
//{
//	int i;
//	char c;
//};
//int main()
//{
//	union Un u;
//	u.i = 0x00000001;
//	if (u.c == 1)
//		printf("小端\n");
//	else
//		printf("大端\n");
//	return 0;
//}


//char* compressString(char* S)
//{
//    char* dst = S;
//    char* temp = (char*)malloc(sizeof(char) * (strlen(S) * 2 + 1));
//    int i = 0;
//    while (*dst != '\0')
//    {
//        temp[i++] = *dst;
//        char* move = dst;
//        int count = 0;
//        while (*move != '\0' && *move == *dst)
//        {
//            count++;
//            ++move;
//        }
//        char str[100];
//        sprintf(str, "%d", count);
//        strcpy(temp + i, str);
//        i += strlen(str);
//        dst = move;
//    }
//    temp[i] = '\0';
//    if (strlen(temp) >= strlen(S))
//    {
//        free(temp);
//        return S;
//    }
//    else
//        return temp;
//}
//
//int main()
//{
//    char s[] = "";
//    printf("%s\n", compressString(s));
//    return 0;
//}



//int main()
//{
//	const char* s1 = "0123456789";
//	cout << sizeof(s1) << endl; // 因为这时的参数s1是一个指向字符串常量的字符指针，因此计算的是指针的大小；
//	// 注意这里不同编译器得到的值可能不同，32位机器下指针大小为4个字节，64位机器下指针大小为8个字节
//	cout << sizeof(*s1) << endl; // 输出1， *s是第一个字符'0'
//	cout << strlen(s1) << endl; //输出10，有10个字符，str1en是个函数，内部实现是用一个循环计算到'\0'之前为止
//	// strlen(*sl); //报错，因为str1en函数的参数类型只能是char*即字符串,*s1是一个字符
//	char s2[] = "0123456789"; //动态数组
//	cout << sizeof(s2) << endl; //结果为11，数组名虽然本质是一个指针，但是作为sizeof的参数时，计算的是整个数组的大小(这点要特别注意)。
//	// 且在求动态数组的大小时，sizeof统计到第一个结束字符'\0'处结束 (包括'\0'所占的空间)
//	cout << strlen(s2) << endl; //结果为10
//	cout << sizeof(*s2) << endl; //结果为1，*s2是第一个字符
//	char s3[100] = "0123456789";
//	cout << sizeof(s3) << endl;  // 结果为100，因为内存给数组s3分配了字节数为100的空间大小
//	cout << strlen(s3) << endl; // 结果为10
//	int s4[100] = { 0,1,2,3,4,5,6,7,8,9 };
//	cout << sizeof(s4) << endl; //结果为400，因为int数组中每个元素都是int型，int型占用4字节
//	// strlen(s4); // 报错，strlen不能以int * 作为函数参数
//
//	char p[] = { 'a','b','c','d','e','f','g','h'};
//	char q[] = { 'a', 'b', 'c', 'd', '\0','e','f','g'};
//	cout << sizeof(p) << endl; // 结果为8,计算结果为八个字符的大小
//	cout << strlen(p) << endl; // 结果是一个随机数，因为字符串数组中没有结束字符\0'，因此该函数会一直统计下去，直到碰到内存中的结束字符
//	cout << sizeof(q) << endl; // 结果还是8,计算结果为八个字符的大小
//	cout << strlen(q) << endl; // 结果为4，结束字符\0'前有4个字符
//	return 0;
//}

//string addStrings(string num1, string num2)
//{
//    // 将两个数变为相同长度的字符串
//    int len1 = num1.size();
//    int len2 = num2.size();
//    int n = len1 - len2;
//    if (n != 0)
//    {
//        if (n > 0)
//        {
//            while (n--)
//                num2.insert(num2.begin(), '0');
//        }
//        else
//        {
//            n *= -1;
//            while (n--)
//                num1.insert(num1.begin(), '0');
//        }
//    }
//    int carry = 0; // 进位
//    int i = num1.size() - 1;
//    string ret;
//    while (i >= 0)
//    {
//        int n1 = num1[i] - '0';
//        int n2 = num2[i] - '0';
//        if (carry > 0)
//        {
//            ret.insert(ret.begin(),((n1 + n2 + carry) % 10 + '0'));
//        }
//        else
//            ret.insert(ret.begin(), ((n1 + n2) % 10 + '0'));
//        carry = (n1 + n2 + carry) / 10;
//        i--;
//    }
//    if(carry > 0)
//        ret.insert(ret.begin(), (carry + '0'));
//    return ret;
//}

//int main()
//{
//    string num1 = "9";
//    string num2 = "99";
//    cout << addStrings(num1, num2) << endl;
//    return 0;
//}

//int main()
//{
//	/*cout << string::npos << endl;*/
//	cout << sizeof(size_t) << endl;
//	cout << sizeof(unsigned int) << endl;
//	cout << sizeof(int) << endl;
//	return 0;
//}

//string(const char* str)
//	:_str(str), _size(strlen(str)), _capacity(strlen(str))
//{
//
//}

//string(const char* str)
//	: _size(strlen(str))
//{
//	_capacity = _size;
//	_str = new char[_capacity + 1];
//	strcpy(_str, str);
//}

//int globalVar = 1;
//
//static int staticGlobalVar = 1;
//
//void Test()
//{
//	static int staticVar = 1;
//	int localVar = 1;
//	int num1[10] = { 1, 2, 3, 4 };
//	char char2[] = "abcd";
//	char* pChar3 = "abcd";
//	int* ptr1 = (int*)malloc(sizeof(int) * 4);
//	int* ptr2 = (int*)calloc(4, sizeof(int));
//	int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
//	free(ptr1);
//	free(ptr3);
//}



//1. 选择题：
//
//选项 : A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
//
//globalVar在哪里？_C_  staticGlobalVar在哪里？__C__
//
//staticVar在哪里？__C__  localVar在哪里？__A__
//
//num1 在哪里？__A__
//
//
//
//char2在哪里？__A__ * char2在哪里？_D__
//
//pChar3在哪里？_A___ * pChar3在哪里？__D__
//
//ptr1在哪里？__A__ * ptr1在哪里？__B__
//
//
//
//2. 填空题：
//
//sizeof(num1) = _40_;
//
//sizeof(char2) = __4/8__;   strlen(char2) = __5__;
//
//sizeof(pChar3) = __4/8__;   strlen(pChar3) = __4__;
//
//sizeof(ptr1) = __4/8__;


//class A
//{
//public:
//	A()
//	{
//		cout << "A()" << endl;
//	}
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//};
//
//int main()
//{
//	A* pa = new A[5];
//	delete pa;
// 
//	char* p = new char[100];
//	delete p;
//	return 0;
//}

//int main(int argc, char* argv[])
//
//{
//
//	string a = "hello world"; // 构造函数
//
//	string b = a; // 拷贝构造函数
//
//	if (a.c_str() == b.c_str())
//		cout << "true" << endl;
//	else cout << "false" << endl;
//
//	string c = b; // 拷贝构造函数
//
//	c = ""; // 赋值重载
//
//	if (a.c_str() == b.c_str())
//
//	{
//
//		cout << "true" << endl;
//
//	}
//
//	else cout << "false" << endl;
//
//	a = "";
//
//	if (a.c_str() == b.c_str())
//
//	{
//
//		cout << "true" << endl;
//
//	}
//
//	else cout << "false" << endl;
//
//	return 0;
//
//}


//int main()
//{
//    string str;
//    cin >> str;
//    int ret = str.rfind(' ');
//    ret = str.size() - ret - 1;
//    cout << ret;
//}

// 实现string类的接口，并完成测试，要求利用深拷贝和深赋值实现
//
//class string
//{
//public:
//	string(const char* str = "")
//		:_str(new char[strlen(str) + 1])
//	{
//		strcpy(_str, str);
//	}
//
//	string(const string& s)
//		:_str(new char[strlen(s._str) + 1])
//	{
//		strcpy(_str, s._str);
//	}
//
//	string& operator=(const string& s)
//	{
//		if (this == &s)
//			return *this;
//		delete[] _str;
//		_str = new char[strlen(s._str) + 1];
//		strcpy(_str, s._str);
//		return *this;
//	}
//
//	~string()
//	{
//		delete[] _str;
//		_str = nullptr;
//	}
//
//private:
//	char* _str;
//};

//#include <stdio.h> 
//typedef struct List_t 
//{
//	struct List_t* next; 
//	struct List_t* prev; 
//	char data[0];
//}list_t;
//int main()
//{
//	printf("%d", sizeof(list_t)); 
//	return 0;
//}

//int multiply_(int a, int count)
//{
//    if (count == 0)
//        return 0;
//    return a += multiply_(a, count-1);
//}
//int multiply(int A, int B)
//{
//    int count = B;
//
//    return multiply_(A, count);
//}
//
//int main()
//{
//    cout << multiply(1, 10) << endl;
//    return 0;
//}

// 挑7

//int removeDuplicates(vector<int>& nums)
//{
//
//    vector<int>::iterator j = nums.begin();
//    for (j; j != nums.end(); j++)
//    {
//        vector<int>::iterator i = j + 1;
//        while (i != nums.end() && * i == *j)
//        {
//            i = nums.erase(i);
//        }
//    }
//    return nums.size();
//}
//
//int main()
//{
//    vector<int> v = { 1,2,2 };
//    cout << removeDuplicates(v) << endl;
//    for (auto e : v)
//    {
//        cout << e << " ";
//    }
//    return 0;
//}

//int main()
//{
//	int n = INT_MIN;
//	int ret = n & (-n);
//	cout << ret << endl;
//	cout << INT_MIN << endl;
//	return 0;
//}

//int main()
//{
//	vector<string> vstr;
//
//	string s1("张三");
//	vstr.push_back(s1); // 第一种插入方法
//
//	vstr.push_back(string("李四")); // 第二种插入方法
//
//	vstr.push_back("王五"); // 第三种插入方法：隐式类型转化
//
//	for (const auto& e : vstr)
//		cout << e;
//	cout << endl;
//
//	cout << vstr[0][0]; // 只取出了'张'的第一个字节
//	cout << vstr[0][1] << endl; // 取出了'张'的第二个字节
//	return 0;
//}

//int main()
//{
//	string s1("abcdefg");
//	vector<int> v1(s1.begin(), s1.end());
//	for (auto n : v1)
//	{
//		cout << n << " ";
//	}
//	cout << endl;
//	vector<int> v2(s1.begin()+2, --s1.end());
//	for (auto n : v2)
//	{
//		cout << n << " ";
//	}
//	cout << endl;
//	return 0;
//}



//int main()
//{
//
//	int ar[] = { 1,2,3,4,0,5,6,7,8,9 };
//
//	int n = sizeof(ar) / sizeof(int);
//
//	vector<int> v(ar, ar + n);
//
//	vector<int>::iterator it = v.begin();
//
//	while (it != v.end())
//
//	{
//
//		if (*it != 0)
//
//			cout << *it;
//
//		else
//
//			v.erase(it);
//
//		it++;
//
//	}
//
//	return 0;
//
//}

//#include <stdio.h>
//int main()
//{
//	FILE* pFile;
//	pFile = fopen("example.txt", "wb"); 
//	fputs("This is an apple.", pFile);
//	fseek(pFile, 9, SEEK_SET);
//	fputs(" sam", pFile);
//	fclose(pFile);
//	return 0;
//}

//int main()
//{
//    float num = 0.0f;
//    cin >> num;
//    int integer = num;
//    float cmp = (num - (float)integer);
//    if (cmp >= 0.5)
//        integer++;
//    cout << integer;
//}

//#define a 10 
//int main()
//{
//	printf("%d..", a);
//	#undef a 
//	#define a 50 
//	printf("%d", a);
//	return 0;
//}


// 日期差值
//#include <iostream>
//
//using namespace std;
//
///*
//
//*思路：
//
//* 1. 分别求出每一个日期与0000年0月1日距离的天数
//
//* 2. 两个距离天数相减即可得到两个日期相差的天数
//
//*/
//
////平年从1月到n月的天数
//int mon[12] = { 0,31,59,90,120,151,181,212,243,273,304,334 };
////给出年月日，计算距离0000年0月1日的天数和
//
//int CountDay(int y, int m, int d)
//{
//    // 计算0-y年的天数
//    int yearDay = y * 365 + (y / 4 - y / 100 + y / 400); // 处理闰年问题
//    // 计算到0-m月的天数
//    int monthDay = mon[m - 1];
//    if (m > 2 && ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0))
//        monthDay += 1;
//    return yearDay + monthDay + d;
//}
//
//int main()
//{
//    int year1, month1, day1;
//    scanf("%4d%2d%2d", &year1, &month1, &day1);
//    int n1 = CountDay(year1, month1, day1);
//    int year2, month2, day2;
//    scanf("%4d%2d%2d", &year2, &month2, &day2);
//    int n2 = CountDay(year2, month2, day2);
//    cout << abs(n1 - n2) + 1 << endl;
//}



//bool IsPopOrder(vector<int>& pushV, vector<int>& popV)
//{
//    // write code here
//    int push = 0, pop = 0;
//    stack<int> st;
//    while (!st.empty() && push < pushV.size())
//    {
//        // 入栈序列当前元素入栈
//        if (push < pushV.size())
//            st.push(pushV[push++]);
//        // 比较
//        while (!st.empty() && st.top() == popV[pop])
//        {
//            st.pop();
//            pop++;
//        }
//    }
//    if (pop == popV.size())
//        return true;
//    else
//        return false;
//
//}
//
//int main()
//{
//    vector<int> pushV;
//    vector<int> popV;
//    pushV.push_back(1);
//    popV.push_back(2);
//    cout << IsPopOrder(pushV, popV);
//    return 0;
//}


//int main()
//{
//	printf("%5.10s\n", "computer");
//	return 0;
//}

//#include <vector>
//#include <iostream>
//#include <algorithm>
//using namespace std;
//
//int main()
//{
//    int n = 0;
//    cin >> n;
//    vector<int> v(n * 3);
//    for (int i = 0; i < n * 3; i++)
//    {
//        cin >> v[i];
//    }
//    // 排序
//    sort(v.begin(), v.end());
//    int end = v.size() - 2;
//    int ret = 0;
//    while (n--)
//    {
//        ret += v[end];
//        end -= 2;
//    }
//    cout << ret;
//    return ret;
//}

//int main()
//{
//	char x[] = "abc";
//	char y[] = { 'a', 'b', 'c' };
//	cout << sizeof(x) << endl;
//	cout << sizeof(y) << endl;
//	return 0;
//}


//bool lessFunc(int x, int y)
//{
//	return x < y;
//}
//bool greaterFunc(int x, int y)
//{
//	return x > y;
//}
//
//class A
//{
//	// 在类A中如果想使用这个函数，就必须定义一个函数指针保存函数的地址
//public:
//	A(bool (*pfunc)(int, int))
//		:_pfunc(pfunc)
//	{}
//
//	// 调用这个函数
//	void func(int x, int y)
//	{
//		cout << _pfunc(x, y) << endl;
//	}
//	bool (*_pfunc) (int, int); // 函数指针
//};
//
//int main()
//{
//	A a1(lessFunc); // 调用小于的函数
//	a1.func(1,2);
//	A a2(greaterFunc); // 调用大于的函数
//	a2.func(1,2);
//
//	return 0;
//}

//class lessFunc
//{
//public:
//	bool operator()(int x, int y)
//	{
//		return x < y;
//	}
//};
//
//class greaterFunc
//{
//public:
//	bool operator()(int x, int y)
//	{
//		return x > y;
//	}
//};
//template<class compare>
//class A
//{
//	// 在类A中如果想使用这个函数，就必须定义一个函数指针保存函数的地址
//public:
//
//
//	// 调用这个函数
//	void func(int x, int y)
//	{
//		compare cmp;
//		cout << cmp(x, y) << endl;
//	}
//
//};
//
//int main()
//{
//	A<lessFunc> a1; // 调用小于的仿函数
//	a1.func(1, 2);
//	A<greaterFunc> a2; // 调用大于的仿函数
//	a2.func(1, 2);
//	return 0;
//}

//priority_queue<int, vector<int>, greater<int>> pq;
//
//sort(nums.begin(), nums.end(), greater<int>());

//int main()
//{
//	vector<int> v;
//	v.push_back(1);
//	v.push_back(9);
//	v.push_back(5);
//	v.push_back(2);
//	v.push_back(4);
//
//	for (auto e : v)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	sort(v.begin(), v.end(), greater<int>());
//	return 0;
//}

//#define N 10
//
//template<class T>
//class Stack
//{
//
//private:
//	T _a[N];
//	int _top;
//};
//
//int main()
//{
//	Stack<int> st1;
//	Stack<int> st2;
//	return 0;
//}



//template<class T, size_t N>
//class Stack
//{
//
//private:
//	T _a[N];
//	int _top;
//};
//
//int main()
//{
//	Stack<int, 10> st1;
//	Stack<int, 20> st2;
//	return 0;
//}

